home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 January: Mac OS SDK / Dev.CD Jan 97 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Interfaces / PInterfaces / OpenTransport.p < prev    next >
Encoding:
Text File  |  1996-02-13  |  56.6 KB  |  1,490 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        OpenTransport.p
  3.  
  4.      Contains:    OpenTransport interfaces
  5.  
  6.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  7.                  All rights reserved.
  8.  
  9. }
  10.  
  11. {$IFC UNDEFINED UsingIncludes}
  12. {$SETC UsingIncludes := 0}
  13. {$ENDC}
  14.  
  15. {$IFC NOT UsingIncludes}
  16.  UNIT OpenTransport;
  17.  INTERFACE
  18. {$ENDC}
  19.  
  20. {$IFC UNDEFINED __OPENTRANSPORT__}
  21. {$SETC __OPENTRANSPORT__ := 1}
  22.  
  23. {$I+}
  24. {$SETC OpenTransportIncludes := UsingIncludes}
  25. {$SETC UsingIncludes := 1}
  26.  
  27. {$SETC SystemSevenOrLater := 1}
  28.  
  29. {$IFC UNDEFINED __TYPES__}
  30. {$I Types.p}
  31. {$ENDC}
  32. {    ConditionalMacros.p                                            }
  33.  
  34. {$IFC UNDEFINED __MIXEDMODE__}
  35. {$I MixedMode.p}
  36. {$ENDC}
  37.  
  38. {$IFC UNDEFINED __STRINGS__}
  39. {$I Strings.p}
  40. {$ENDC}
  41.     
  42. TYPE
  43.     size_t = LONGINT;
  44.  
  45. {$SETC NULL := 0}
  46.  
  47. {$PUSH}
  48. {$ALIGN MAC68K}
  49. {$LibExport+}
  50.     uchar_p = LONGINT;
  51.  
  52.     ushort_p = LONGINT;
  53.  
  54.     short_p = LONGINT;
  55.  
  56.     char_p = LONGINT;
  57.  
  58.     boolean_p = LONGINT;
  59.  
  60. {$IFC UNDEFINED OTKERNEL }
  61. {$SETC OTKERNEL := 0}
  62. {$ENDC}
  63.  
  64. CONST
  65.     gestaltOpenTptVersions        = 'otvr';
  66.     gestaltOpenTpt                = 'otan';
  67.     gestaltOpenTptPresent        = $00000001;
  68.     gestaltOpenTptLoaded        = $00000002;
  69.     gestaltOpenTptAppleTalkPresent = $00000004;
  70.     gestaltOpenTptAppleTalkLoaded = $00000008;
  71.     gestaltOpenTptTCPPresent    = $00000010;
  72.     gestaltOpenTptTCPLoaded        = $00000020;
  73.     gestaltOpenTptIPXSPXPresent    = $00000040;
  74.     gestaltOpenTptIPXSPXLoaded    = $00000080;
  75.  
  76. {******************************************************************************
  77. ** Some prefixes for shared libraries
  78. *******************************************************************************}
  79.     kOTLibraryVersion    =    '1.0';
  80.     kOTLibraryPrefix    =    'OTLib$';
  81.     kOTModulePrefix    =    'OTModl$';
  82.     kOTKernelPrefix    =    'OTKrnl$';
  83.     kOTClientPrefix    =    'OTClnt$';
  84.     kOTSupportPrefix    =    'OTSupp$';
  85. {******************************************************************************
  86. ** Some typedefs used by the OpenTransport system
  87. *******************************************************************************}
  88. {    -------------------------------------------------------------------------
  89.     Miscellaneous typedefs
  90.     ------------------------------------------------------------------------- }
  91.     
  92. TYPE
  93.     OTTimeout = UInt32;
  94.  
  95.     OTSequence = LONGINT;
  96.  
  97.     OTNameID = LONGINT;
  98.  
  99.     OTReason = SInt32;
  100.  
  101.     OTQLen = UInt32;
  102.  
  103.     OTClient = Ptr;
  104.  
  105.     OTClientName = ^UInt8;
  106.  
  107.     OTOpenFlags = UInt32;
  108.  
  109.  
  110. CONST
  111.     O_ASYNC                        = $01;
  112.     O_NDELAY                    = $04;
  113.     O_NONBLOCK                    = $04;
  114.  
  115. {    -------------------------------------------------------------------------
  116.     StdCLib-style Error codes
  117.     ------------------------------------------------------------------------- }
  118.     
  119. TYPE
  120.     OTUnixErr = UInt16;
  121.  
  122. {
  123.          * There may be some error code confusions with other compiler vendor header
  124.          * files - However, these match both MPW and AIX definitions.
  125.          * We undefine the #defined ones we know about so that we can put them
  126.          * in an enum.
  127.          }
  128.  
  129. CONST
  130.     EPERM                        = 1;                            { Permission denied                    }
  131.     ENOENT                        = 2;                            { No such file or directory            }
  132.     ENORSRC                        = 3;                            { No such resource                        }
  133.     EINTR                        = 4;                            { Interrupted system service            }
  134.     EIO                            = 5;                            { I/O error                            }
  135.     ENXIO                        = 6;                            { No such device or address            }
  136.     EBADF                        = 9;                            { Bad file number                        }
  137.     EAGAIN                        = 11;                            { Try operation again later            }
  138.     ENOMEM                        = 12;                            { Not enough space                        }
  139.     EACCES                        = 13;                            { Permission denied                    }
  140.     EFAULT                        = 14;                            { Bad address                            }
  141.     EBUSY                        = 16;                            { Device or resource busy                }
  142.     EEXIST                        = 17;                            { File exists                            }
  143.     ENODEV                        = 19;                            { No such device                        }
  144.     EINVAL                        = 22;                            { Invalid argument                        }
  145.     ENOTTY                        = 25;                            { Not a character device                }
  146.     EPIPE                        = 32;                            { Broken pipe                            }
  147.     ERANGE                        = 34;                            { Math result not representable        }
  148.     EDEADLK                        = 35;                            { Call would block so was aborted        }
  149.     EWOULDBLOCK                    = EDEADLK;                        { Or a deadlock would occur            }
  150.     EALREADY                    = 37;
  151.     ENOTSOCK                    = 38;                            { Socket operation on non-socket        }
  152.     EDESTADDRREQ                = 39;                            { Destination address required            }
  153.     EMSGSIZE                    = 40;                            { Message too long                        }
  154.     EPROTOTYPE                    = 41;                            { Protocol wrong type for socket        }
  155.     ENOPROTOOPT                    = 42;                            { Protocol not available                }
  156.     EPROTONOSUPPORT                = 43;                            { Protocol not supported                }
  157.     ESOCKTNOSUPPORT                = 44;                            { Socket type not supported            }
  158.     EOPNOTSUPP                    = 45;                            { Operation not supported on socket    }
  159.     EADDRINUSE                    = 48;                            { Address already in use                }
  160.     EADDRNOTAVAIL                = 49;                            { Can't assign requested address        }
  161.     ENETDOWN                    = 50;                            { Network is down                        }
  162.     ENETUNREACH                    = 51;                            { Network is unreachable                }
  163.     ENETRESET                    = 52;                            { Network dropped connection on reset    }
  164.     ECONNABORTED                = 53;                            { Software caused connection abort        }
  165.     ECONNRESET                    = 54;                            { Connection reset by peer                }
  166.     ENOBUFS                        = 55;                            { No buffer space available            }
  167.     EISCONN                        = 56;                            { Socket is already connected            }
  168.     ENOTCONN                    = 57;                            { Socket is not connected                }
  169.     ESHUTDOWN                    = 58;                            { Can't send after socket shutdown        }
  170.     ETOOMANYREFS                = 59;                            { Too many references: can't splice    }
  171.     ETIMEDOUT                    = 60;                            { Connection timed out                    }
  172.     ECONNREFUSED                = 61;                            { Connection refused                    }
  173.     EHOSTDOWN                    = 64;                            { Host is down                            }
  174.     EHOSTUNREACH                = 65;                            { No route to host                        }
  175.     EPROTO                        = 70;
  176.     ETIME                        = 71;
  177.     ENOSR                        = 72;
  178.     EBADMSG                        = 73;
  179.     ECANCEL                        = 74;
  180.     ENOSTR                        = 75;
  181.     ENODATA                        = 76;
  182.     EINPROGRESS                    = 77;
  183.     ESRCH                        = 78;
  184.     ENOMSG                        = 79;
  185.     ELASTERRNO                    = 79;
  186.  
  187. {    -------------------------------------------------------------------------
  188.     Open Transport/XTI Error codes
  189.     ------------------------------------------------------------------------- }
  190.     
  191. TYPE
  192.     OTXTIErr = UInt16;
  193.  
  194.  
  195. CONST
  196.     TSUCCESS                    = 0;                            { No Error occurred                        }
  197.     TBADADDR                    = 1;                            { A Bad address was specified                }
  198.     TBADOPT                        = 2;                            { A Bad option was specified                }
  199.     TACCES                        = 3;                            { Missing access permission                }
  200.     TBADF                        = 4;                            { Bad provider reference                    }
  201.     TNOADDR                        = 5;                            { No address was specified                    }
  202.     TOUTSTATE                    = 6;                            { Call issued in wrong state                }
  203.     TBADSEQ                        = 7;                            { Sequence specified does not exist        }
  204.     TSYSERR                        = 8;                            { A system error occurred                    }
  205.     TLOOK                        = 9;                            { An event occurred - call Look()            }
  206.     TBADDATA                    = 10;                            { An illegal amount of data was specified    }
  207.     TBUFOVFLW                    = 11;                            { Passed buffer not big enough                }
  208.     TFLOW                        = 12;                            { Provider is flow-controlled                }
  209.     TNODATA                        = 13;                            { No data available for reading            }
  210.     TNODIS                        = 14;                            { No disconnect indication available        }
  211.     TNOUDERR                    = 15;                            { No Unit Data Error indication available    }
  212.     TBADFLAG                    = 16;                            { A Bad flag value was supplied            }
  213.     TNOREL                        = 17;                            { No orderly release indication available    }
  214.     TNOTSUPPORT                    = 18;                            { Command is not supported                    }
  215.     TSTATECHNG                    = 19;                            { State is changing - try again later        }
  216.     TNOSTRUCTYPE                = 20;                            { Bad structure type requested for OTAlloc    }
  217.     TBADNAME                    = 21;                            { A bad endpoint name was supplied            }
  218.     TBADQLEN                    = 22;                            { A Bind to an in-use address with qlen > 0}
  219.     TADDRBUSY                    = 23;                            { Address requested is already in use        }
  220.     TINDOUT                        = 24;                            { Accept failed because of pending listen    }
  221.     TPROVMISMATCH                = 25;                            { Tried to accept on incompatible endpoint    }
  222.     TRESQLEN                    = 26;
  223.     TRESADDR                    = 27;
  224.     TQFULL                        = 28;
  225.     TPROTO                        = 29;                            { An unspecified provider error occurred    }
  226.     TBADSYNC                    = 30;                            { A synchronous call at interrupt time        }
  227.     TCANCELED                    = 31;                            { The command was cancelled                }
  228.     TLASTXTIERROR                = 31;
  229.  
  230. {    -------------------------------------------------------------------------
  231.     Standard negative error codes conforming to both the Open Transport/XTI
  232.     errors and the Exxxxx StdCLib errors.
  233.     These are returned as OSStatus' from functions, and to the OTResult parameter
  234.     of a notification function or method.  However, OTResult may sometimes
  235.     contain other values depending on the notification.
  236.     ------------------------------------------------------------------------- }
  237.     
  238. TYPE
  239.     OTResult = SInt32;
  240.  
  241. {
  242.          * These map the Open Transport/XTI errors (the Txxxx error codes), and the
  243.          * StdCLib Exxxx error codes into unique spaces in the Apple OSStatus space.
  244.          }
  245.  
  246. CONST
  247.     kOTNoError                    = 0;                            { No Error occurred                        }
  248.     kOTOutOfMemoryErr            = 0+(-3199 - (ENOMEM));
  249.     kOTNotFoundErr                = 0+(-3199 - (ENOENT));
  250.     kOTDuplicateFoundErr        = 0+(-3199 - (EEXIST));
  251. {
  252.              * Remapped XTI error codes
  253.              }
  254.     kOTBadAddressErr            = 0+(-3149 - (TBADADDR));        { A Bad address was specified                }
  255.     kOTBadOptionErr                = 0+(-3149 - (TBADOPT));        { A Bad option was specified                }
  256.     kOTAccessErr                = 0+(-3149 - (TACCES));            { Missing access permission                }
  257.     kOTBadReferenceErr            = 0+(-3149 - (TBADF));            { Bad provider reference                    }
  258.     kOTNoAddressErr                = 0+(-3149 - (TNOADDR));        { No address was specified                    }
  259.     kOTOutStateErr                = 0+(-3149 - (TOUTSTATE));        { Call issued in wrong state                }
  260.     kOTBadSequenceErr            = 0+(-3149 - (TBADSEQ));        { Sequence specified does not exist        }
  261.     kOTSysErrorErr                = 0+(-3149 - (TSYSERR));        { A system error occurred                    }
  262.     kOTLookErr                    = 0+(-3149 - (TLOOK));            { An event occurred - call Look()            }
  263.     kOTBadDataErr                = 0+(-3149 - (TBADDATA));        { An illegal amount of data was specified    }
  264.     kOTBufferOverflowErr        = 0+(-3149 - (TBUFOVFLW));        { Passed buffer not big enough                }
  265.     kOTFlowErr                    = 0+(-3149 - (TFLOW));            { Provider is flow-controlled                }
  266.     kOTNoDataErr                = 0+(-3149 - (TNODATA));        { No data available for reading            }
  267.     kOTNoDisconnectErr            = 0+(-3149 - (TNODIS));            { No disconnect indication available        }
  268.     kOTNoUDErrErr                = 0+(-3149 - (TNOUDERR));        { No Unit Data Error indication available    }
  269.     kOTBadFlagErr                = 0+(-3149 - (TBADFLAG));        { A Bad flag value was supplied            }
  270.     kOTNoReleaseErr                = 0+(-3149 - (TNOREL));            { No orderly release indication available    }
  271.     kOTNotSupportedErr            = 0+(-3149 - (TNOTSUPPORT));    { Command is not supported                    }
  272.     kOTStateChangeErr            = 0+(-3149 - (TSTATECHNG));        { State is changing - try again later        }
  273.     kOTNoStructureTypeErr        = 0+(-3149 - (TNOSTRUCTYPE));    { Bad structure type requested for OTAlloc    }
  274.     kOTBadNameErr                = 0+(-3149 - (TBADNAME));        { A bad endpoint name was supplied            }
  275.     kOTBadQLenErr                = 0+(-3149 - (TBADQLEN));        { A Bind to an in-use addr with qlen > 0    }
  276.     kOTAddressBusyErr            = 0+(-3149 - (TADDRBUSY));        { Address requested is already in use        }
  277.     kOTIndOutErr                = 0+(-3149 - (TINDOUT));        { Accept failed because of pending listen    }
  278.     kOTProviderMismatchErr        = 0+(-3149 - (TPROVMISMATCH));    { Tried to accept on incompatible endpoint    }
  279.     kOTResQLenErr                = 0+(-3149 - (TRESQLEN));
  280.     kOTResAddressErr            = 0+(-3149 - (TRESADDR));
  281.     kOTQFullErr                    = 0+(-3149 - (TQFULL));
  282.     kOTProtocolErr                = 0+(-3149 - (TPROTO));            { An unspecified provider error occurred    }
  283.     kOTBadSyncErr                = 0+(-3149 - (TBADSYNC));        { A synchronous call at interrupt time        }
  284.     kOTCanceledErr                = 0+(-3149 - (TCANCELED));        { The command was cancelled                }
  285. {
  286.              * Remapped StdCLib error codes. %%% Remove ones we don't actually return.
  287.              }
  288.     kEPERMErr                    = 0+(-3199 - (EPERM));            { Permission denied                    }
  289.     kENOENTErr                    = 0+(-3199 - (ENOENT));            { No such file or directory            }
  290.     kENORSRCErr                    = 0+(-3199 - (ENORSRC));        { No such resource                        }
  291.     kEINTRErr                    = 0+(-3199 - (EINTR));            { Interrupted system service            }
  292.     kEIOErr                        = 0+(-3199 - (EIO));            { I/O error                            }
  293.     kENXIOErr                    = 0+(-3199 - (ENXIO));            { No such device or address            }
  294.     kEBADFErr                    = 0+(-3199 - (EBADF));            { Bad file number                        }
  295.     kEAGAINErr                    = 0+(-3199 - (EAGAIN));            { Try operation again later            }
  296.     kENOMEMErr                    = 0+(-3199 - (ENOMEM));            { Not enough space                        }
  297.     kEACCESErr                    = 0+(-3199 - (EACCES));            { Permission denied                    }
  298.     kEFAULTErr                    = 0+(-3199 - (EFAULT));            { Bad address                            }
  299.     kEBUSYErr                    = 0+(-3199 - (EBUSY));            { Device or resource busy                }
  300.     kEEXISTErr                    = 0+(-3199 - (EEXIST));            { File exists                            }
  301.     kENODEVErr                    = 0+(-3199 - (ENODEV));            { No such device                        }
  302.     kEINVALErr                    = 0+(-3199 - (EINVAL));            { Invalid argument                        }
  303.     kENOTTYErr                    = 0+(-3199 - (ENOTTY));            { Not a character device                }
  304.     kEPIPEErr                    = 0+(-3199 - (EPIPE));            { Broken pipe                            }
  305.     kERANGEErr                    = 0+(-3199 - (ERANGE));            { Message size too large for STREAM    }
  306.     kEWOULDBLOCKErr                = 0+(-3199 - (EWOULDBLOCK));    { Call would block, so was aborted        }
  307.     kEDEADLKErr                    = 0+(-3199 - (EDEADLK));        { or a deadlock would occur            }
  308.     kEALREADYErr                = 0+(-3199 - (EALREADY));
  309.     kENOTSOCKErr                = 0+(-3199 - (ENOTSOCK));        { Socket operation on non-socket        }
  310.     kEDESTADDRREQErr            = 0+(-3199 - (EDESTADDRREQ));    { Destination address required            }
  311.     kEMSGSIZEErr                = 0+(-3199 - (EMSGSIZE));        { Message too long                        }
  312.     kEPROTOTYPEErr                = 0+(-3199 - (EPROTOTYPE));        { Protocol wrong type for socket        }
  313.     kENOPROTOOPTErr                = 0+(-3199 - (ENOPROTOOPT));    { Protocol not available                }
  314.     kEPROTONOSUPPORTErr            = 0+(-3199 - (EPROTONOSUPPORT)); { Protocol not supported                }
  315.     kESOCKTNOSUPPORTErr            = 0+(-3199 - (ESOCKTNOSUPPORT)); { Socket type not supported            }
  316.     kEOPNOTSUPPErr                = 0+(-3199 - (EOPNOTSUPP));        { Operation not supported on socket    }
  317.     kEADDRINUSEErr                = 0+(-3199 - (EADDRINUSE));        { Address already in use                }
  318.     kEADDRNOTAVAILErr            = 0+(-3199 - (EADDRNOTAVAIL));    { Can't assign requested address        }
  319.     kENETDOWNErr                = 0+(-3199 - (ENETDOWN));        { Network is down                        }
  320.     kENETUNREACHErr                = 0+(-3199 - (ENETUNREACH));    { Network is unreachable                }
  321.     kENETRESETErr                = 0+(-3199 - (ENETRESET));        { Network dropped connection on reset    }
  322.     kECONNABORTEDErr            = 0+(-3199 - (ECONNABORTED));    { Software caused connection abort        }
  323.     kECONNRESETErr                = 0+(-3199 - (ECONNRESET));        { Connection reset by peer                }
  324.     kENOBUFSErr                    = 0+(-3199 - (ENOBUFS));        { No buffer space available            }
  325.     kEISCONNErr                    = 0+(-3199 - (EISCONN));        { Socket is already connected            }
  326.     kENOTCONNErr                = 0+(-3199 - (ENOTCONN));        { Socket is not connected                }
  327.     kESHUTDOWNErr                = 0+(-3199 - (ESHUTDOWN));        { Can't send after socket shutdown        }
  328.     kETOOMANYREFSErr            = 0+(-3199 - (ETOOMANYREFS));    { Too many references: can't splice    }
  329.     kETIMEDOUTErr                = 0+(-3199 - (ETIMEDOUT));        { Connection timed out                    }
  330.     kECONNREFUSEDErr            = 0+(-3199 - (ECONNREFUSED));    { Connection refused                    }
  331.     kEHOSTDOWNErr                = 0+(-3199 - (EHOSTDOWN));        { Host is down                            }
  332.     kEHOSTUNREACHErr            = 0+(-3199 - (EHOSTUNREACH));    { No route to host                        }
  333.     kEPROTOErr                    = 0+(-3199 - (EPROTO));
  334.     kETIMEErr                    = 0+(-3199 - (ETIME));
  335.     kENOSRErr                    = 0+(-3199 - (ENOSR));
  336.     kEBADMSGErr                    = 0+(-3199 - (EBADMSG));
  337.     kECANCELErr                    = 0+(-3199 - (ECANCEL));
  338.     kENOSTRErr                    = 0+(-3199 - (ENOSTR));
  339.     kENODATAErr                    = 0+(-3199 - (ENODATA));
  340.     kEINPROGRESSErr                = 0+(-3199 - (EINPROGRESS));
  341.     kESRCHErr                    = 0+(-3199 - (ESRCH));
  342.     kENOMSGErr                    = 0+(-3199 - (ENOMSG));
  343.     kOTClientNotInittedErr        = 0+(-3199 - (ELASTERRNO + 1));
  344.     kOTPortHasDiedErr            = 0+(-3199 - (ELASTERRNO + 2));
  345.     kOTPortWasEjectedErr        = 0+(-3199 - (ELASTERRNO + 3));
  346.     kOTBadConfigurationErr        = 0+(-3199 - (ELASTERRNO + 4));
  347.     kOTConfigurationChangedErr    = 0+(-3199 - (ELASTERRNO + 5));
  348.     kOTUserRequestedErr            = 0+(-3199 - (ELASTERRNO + 6));
  349.     kOTPortLostConnection        = 0+(-3199 - (ELASTERRNO + 7));
  350.  
  351. {    -------------------------------------------------------------------------
  352.     OTAddressType - defines the address type for the OTAddress
  353.     ------------------------------------------------------------------------- }
  354.     
  355. TYPE
  356.     OTAddressType = UInt16;
  357.  
  358.  
  359. CONST
  360.     kOTGenericName                = 0;
  361.  
  362. {    -------------------------------------------------------------------------
  363.     OTAddress - Generic OpenTransport protocol address
  364.     ------------------------------------------------------------------------- }
  365.  
  366. TYPE
  367.     OTAddress = RECORD
  368.         fAddressType:            OTAddressType;
  369.         fAddress:                PACKED ARRAY [0..0] OF SInt8; (* UInt8 *)
  370.     END;
  371.  
  372. {    -------------------------------------------------------------------------
  373.     OTStructType - defines the structure type for the OTAlloc call
  374.     ------------------------------------------------------------------------- }
  375.     OTStructType = UInt32;
  376.  
  377.  
  378. CONST
  379.     T_BIND                        = 1;
  380.     T_OPTMGMT                    = 2;
  381.     T_CALL                        = 3;
  382.     T_DIS                        = 4;
  383.     T_UNITDATA                    = 5;
  384.     T_UDERROR                    = 6;
  385.     T_INFO                        = 7;
  386.     T_REPLYDATA                    = 8;
  387.     T_REQUESTDATA                = 9;
  388.     T_UNITREQUEST                = 10;
  389.     T_UNITREPLY                    = 11;
  390.  
  391. {    -------------------------------------------------------------------------
  392.     OTFlags - flags for sending and receiving data
  393.     ------------------------------------------------------------------------- }
  394.     
  395. TYPE
  396.     OTFlags = UInt32;
  397.  
  398.  
  399. CONST
  400.     T_MORE                        = $001;                            { More data to come in message        }
  401.     T_EXPEDITED                    = $002;                            { Data is expedited, if possible    }
  402.     T_ACKNOWLEDGED                = $004;                            { Acknowledge transaction            }
  403.     T_PARTIALDATA                = $008;                            { Partial data - more coming        }
  404.     T_NORECEIPT                    = $010;                            { No event on transaction done        }
  405.  
  406. {    -------------------------------------------------------------------------
  407.     OTBand - a band value when reading priority messages
  408.     ------------------------------------------------------------------------- }
  409.     
  410. TYPE
  411.     OTBand = UInt32;
  412.  
  413. {    -------------------------------------------------------------------------
  414.     Reference values
  415.     ------------------------------------------------------------------------- }
  416.     StreamRef = Ptr;
  417.  
  418.     ProviderRef = Ptr;
  419.  
  420.     EndpointRef = Ptr;
  421.  
  422.     MapperRef = Ptr;
  423.  
  424.  
  425. CONST
  426.     kOTInvalidRef                = 0;
  427.     kOTInvalidStreamRef            = 0;
  428.     kOTInvalidProviderRef        = 0;
  429.     kOTInvalidEndpointRef        = 0;
  430.     kOTInvalidMapperRef            = 0;
  431.  
  432. {    -------------------------------------------------------------------------
  433.     OTEventCode values for Open Transport - These are the event codes that
  434.     are sent to notification routine during asynchronous processing.
  435.     ------------------------------------------------------------------------- }
  436.     
  437. TYPE
  438.     OTEventCode = UInt32;
  439.  
  440. {
  441.      * Function definition to handle notification from providers
  442.      }
  443.     OTNotifyProcPtr = ProcPtr;  { PROCEDURE (contextPtr: UNIV Ptr; code: OTEventCode; result: OTResult; cookie: UNIV Ptr); }
  444.  
  445.  
  446. CONST
  447. {
  448.          * These will be returned by the T_LOOK function, or will be returned
  449.          * if asynchronous notification is used.
  450.          }
  451.     T_LISTEN                    = $0001;                        { An connection request is available     }
  452.     T_CONNECT                    = $0002;                        { Confirmation of a connect request    }
  453.     T_DATA                        = $0004;                        { Standard data is available            }
  454.     T_EXDATA                    = $0008;                        { Expedited data is available            }
  455.     T_DISCONNECT                = $0010;                        { A disconnect is available            }
  456.     T_ERROR                        = $0020;                        { obsolete/unused in library            }
  457.     T_UDERR                        = $0040;                        { A Unit Data Error has occurred        }
  458.     T_ORDREL                    = $0080;                        { An orderly release is available        }
  459.     T_GODATA                    = $0100;                        { Flow control lifted on standard data    }
  460.     T_GOEXDATA                    = $0200;                        { Flow control lifted on expedited data}
  461.     T_REQUEST                    = $0400;                        { An Incoming request is available        }
  462.     T_REPLY                        = $0800;                        { An Incoming reply is available        }
  463.     T_PASSCON                    = $1000;                        { State is now T_DATAXFER                }
  464.     T_RESET                        = $2000;                        { Protocol has been reset                }
  465. {
  466.          * kPRIVATEEVENT + 1 through kPRIVATEEVENT + 0xffff
  467.          *        may be used for any private event codes desired.
  468.          *        All other event codes are reserved for Apple Computer, Inc.
  469.          *        use only.
  470.          }
  471.     kPRIVATEEVENT                = $10000000;
  472. {
  473.          * These are only returned if asynchronous notification is being used
  474.          }
  475.     kCOMPLETEEVENT                = $20000000;
  476.     T_BINDCOMPLETE                = $20000001;                    { Bind call is complete                }
  477.     T_UNBINDCOMPLETE            = $20000002;                    { Unbind call is complete                }
  478.     T_ACCEPTCOMPLETE            = $20000003;                    { Accept call is complete                }
  479.     T_REPLYCOMPLETE                = $20000004;                    { SendReply call is complete            }
  480.     T_DISCONNECTCOMPLETE        = $20000005;                    { Disconnect call is complete            }
  481.     T_OPTMGMTCOMPLETE            = $20000006;                    { OptMgmt call is complete                }
  482.     T_OPENCOMPLETE                = $20000007;                    { An Open call is complete                }
  483.     T_GETPROTADDRCOMPLETE        = $20000008;                    { GetProtAddress call is complete        }
  484.     T_RESOLVEADDRCOMPLETE        = $20000009;                    { A ResolveAddress call is complet        }
  485.     T_GETINFOCOMPLETE            = $2000000A;                    { A GetInfo call is complete            }
  486.     T_SYNCCOMPLETE                = $2000000B;                    { A Sync call is complete                }
  487.     T_MEMORYRELEASED            = $2000000C;                    { No-copy memory was released            }
  488.     T_REGNAMECOMPLETE            = $2000000D;                    { A RegisterName call is complete        }
  489.     T_DELNAMECOMPLETE            = $2000000E;                    { A DeleteName call is complete        }
  490.     T_LKUPNAMECOMPLETE            = $2000000F;                    { A LookupName call is complete        }
  491.     T_LKUPNAMERESULT            = $20000010;                    { A LookupName is returning a name        }
  492. {
  493.          * Events for streams - not normally seen by clients.
  494.          }
  495.     kSTREAMEVENT                = $21000000;
  496.     kOTDisablePortEvent            = $21000001;                    { this line deleted for release disk    }
  497.     kGetmsgEvent                = $21000002;                    { A GetMessage call is complete        }
  498.     kStreamReadEvent            = $21000003;                    { A Read call is complete                }
  499.     kStreamWriteEvent            = $21000004;                    { A Write call is complete                }
  500.     kStreamIoctlEvent            = $21000005;                    { An Ioctl call is complete            }
  501.     kStreamOpenEvent            = $21000007;                    { An OpenStream call is complete        }
  502.     kPollEvent                    = $21000008;                    { A Poll call is complete                }
  503.     kSIGNALEVENT                = $22000000;                    { A signal has arrived from the STREAM    }
  504.     kPROTOCOLEVENT                = $23000000;                    { Some event from the protocols        }
  505.     kIMMEDIATEEVENT                = $80000000;                    { This bit or'd in makes it "immediate"}
  506. {
  507.          * These are miscellaneous events that could be sent to a provider
  508.          }
  509.     kOTProviderIsDisconnected    = $23000001;                    { Provider is temporarily off-line        }
  510.     kOTProviderIsReconnected    = $23000002;                    { Provider is now back on-line            }
  511. {
  512.          * These are system events sent to each provider.
  513.          }
  514.     kOTProviderWillClose        = $24000001;                    { Provider will close immediately        }
  515.     kOTProviderIsClosed            = $24000002;                    { Provider was closed                    }
  516. {
  517.          * These are system events sent to registered clients
  518.              *
  519.             * result code is 0, cookie is the OTPortRef
  520.          }
  521.     kOTPortDisabled                = $25000001;                    { Port is now disabled                    }
  522.     kOTPortEnabled                = $25000002;                    { Port is now enabled                    }
  523.     kOTRequestHardware            = $25000003;                    { Request to use hardware                }
  524.     kOTHardwareInUse            = $25000003;                    { specified hardware is in use            }
  525.     kOTReleaseHardware            = $25000004;                    { Release use of hardware                }
  526.     kOTHardwareIsFree            = $25000004;                    { specified hardware is no longer used    }
  527. {
  528.              * A new port has been registered, cookie is the OTPortRef
  529.              }
  530.     kOTNewPortRegistered        = $25000003;                    { New port has been registered            }
  531. {
  532.              * result is a reason for the close request, cookie is a pointer to the 
  533.              * OTPortCloseStruct structure.
  534.              }
  535.     kOTClosePortRequest            = $25000005;                    { Request to close                        }
  536. {
  537.          * These are events sent to the configuration management infrastructure 
  538.          }
  539.     kOTConfigurationChanged        = $26000001;                    { Protocol configuration changed        }
  540.     kOTSystemSleep                = $26000002;
  541.     kOTSystemShutdown            = $26000003;
  542.     kOTSystemAwaken                = $26000004;
  543.     kOTSystemIdle                = $26000005;
  544.  
  545.     SIGHUP                        = 1;
  546.     SIGURG                        = 16;
  547.     SIGPOLL                        = 30;
  548.  
  549. {    -------------------------------------------------------------------------
  550.     Option Management equates
  551.     ------------------------------------------------------------------------- }
  552. {
  553.     ** The XTI Level number of a protocol
  554.     }
  555.     
  556. TYPE
  557.     OTXTILevel = UInt32;
  558.  
  559.  
  560. CONST
  561.     XTI_GENERIC                    = $ffff;                        { level to match any protocol    }
  562.  
  563. {
  564.     ** The XTI name of a protocol option
  565.     }
  566.     
  567. TYPE
  568.     OTXTIName = UInt32;
  569.  
  570. {
  571.          * XTI names for options used with XTI_GENERIC above
  572.          }
  573.  
  574. CONST
  575.     XTI_DEBUG                    = $0001;
  576.     XTI_LINGER                    = $0080;
  577.     XTI_RCVBUF                    = $1002;
  578.     XTI_RCVLOWAT                = $1004;
  579.     XTI_SNDBUF                    = $1001;
  580.     XTI_SNDLOWAT                = $1003;
  581.     XTI_PROTOTYPE                = $1005;
  582.  
  583. {
  584.          * Generic options that can be used with any protocol
  585.          * that understands them
  586.          }
  587.     OPT_CHECKSUM                = $0600;                        { Set checksumming = UInt32 - 0 or 1)}
  588.     OPT_RETRYCNT                = $0601;                        { Set a retry counter = UInt32 (0 = infinite)}
  589.     OPT_INTERVAL                = $0602;                        { Set a retry interval = UInt32 milliseconds}
  590.     OPT_ENABLEEOM                = $0603;                        { Enable the EOM indication = UInt8 (0 or 1)}
  591.     OPT_SELFSEND                = $0604;                        { Enable Self-sending on broadcasts = UInt32 (0 or 1)}
  592.     OPT_SERVERSTATUS            = $0605;                        { Set Server Status (format is proto dependent)}
  593.     OPT_KEEPALIVE                = $0008;                        { See t_keepalive structure}
  594.  
  595. {******************************************************************************
  596. ** Definitions not associated with a Typedef
  597. *******************************************************************************}
  598. {    -------------------------------------------------------------------------
  599.     IOCTL values for the OpenTransport system
  600.     ------------------------------------------------------------------------- }
  601.     MIOC_STREAMIO                = 'A';                            { Basic Stream ioctl() cmds - I_PUSH, I_LOOK, etc. }
  602.     MIOC_STRLOG                    = 'b';                            { ioctl's for Mentat's log device }
  603.     MIOC_SAD                    = 'g';                            { ioctl's for Mentat's sad module }
  604.     MIOC_ARP                    = 'h';                            { ioctl's for Mentat's arp module }
  605.     MIOC_TCP                    = 'k';                            { tcp.h ioctl's }
  606.     MIOC_DLPI                    = 'l';                            { dlpi.h additions }
  607.     MIOC_OT                        = 'O';                            { ioctls for Open Transport    }
  608.     MIOC_ATALK                    = 'T';                            { ioctl's for AppleTalk    }
  609.     MIOC_SRL                    = 'U';                            { ioctl's for Serial        }
  610.     MIOC_SRL_HIGH                = $5400;                        { ioctls for Serial            'U' << 8 }
  611.     MIOC_OT_HIGH                = $4F00;                        { ioctls for Open Transport    'O' << 8 }
  612.     MIOC_SIO_HIGH                = $4100;                        { ioctls for StreamIO            'A' << 8 }
  613.  
  614.     I_STR                        = 0+(MIOC_SIO_HIGH + 8);
  615.     I_FIND                        = 0+(MIOC_SIO_HIGH + 11);
  616.     I_LIST                        = 0+(MIOC_SIO_HIGH + 22);
  617.     I_OTGetMiscellaneousEvents    = 0+(MIOC_OT_HIGH + 1);
  618.     I_OTSetFramingType            = 0+(MIOC_OT_HIGH + 2);
  619.     kOTGetFramingValue            = $ffffffff;
  620.     I_OTSetRawMode                = 0+(MIOC_OT_HIGH + 3);
  621.  
  622. { 
  623.      * structure of ioctl data for I_STR IOCtls
  624.      }
  625.  
  626. TYPE
  627.     strioctl = RECORD
  628.         ic_cmd:                    LONGINT;                                { downstream command    }
  629.         ic_timout:                LONGINT;                                { ACK/NAK timeout        }
  630.         ic_len:                    LONGINT;                                { length of data arg    }
  631.         ic_dp:                    ^CHAR;                                    { ptr to data arg        }
  632.     END;
  633.  
  634. {    -------------------------------------------------------------------------
  635.     Maximum size of a provider name, and maximum size of a STREAM module name.
  636.     This module name is smaller than the maximum size of a TProvider to allow
  637.     for 4 characters of extra "minor number" information that might be 
  638.     potentially in a TProvider name
  639.     ------------------------------------------------------------------------- }
  640.  
  641. CONST
  642.     kMaxModuleNameLength        = 31;
  643.     kMaxModuleNameSize            = kMaxModuleNameLength + 1;
  644.     kMaxProviderNameLength        = kMaxModuleNameLength + 4;
  645.     kMaxProviderNameSize        = kMaxProviderNameLength + 1;
  646.     kMaxSlotIDLength            = 7;
  647.     kMaxSlotIDSize                = 8;
  648.     kMaxResourceInfoLength        = 31;
  649.     kMaxResourceInfoSize        = 32;
  650.  
  651. {    -------------------------------------------------------------------------
  652.     These values are used in the "fields" parameter of the OTAlloc call
  653.     to define which fields of the structure should be allocated.
  654.     ------------------------------------------------------------------------- }
  655.     T_ADDR                        = $01;
  656.     T_OPT                        = $02;
  657.     T_UDATA                        = $04;
  658.     T_ALL                        = $ffff;
  659.  
  660. {    -------------------------------------------------------------------------
  661.     These are the potential values returned by OTGetEndpointState and OTSync
  662.     which represent the state of an endpoint
  663.     ------------------------------------------------------------------------- }
  664.     T_UNINIT                    = 0;                            { addition to standard xti.h    }
  665.     T_UNBND                        = 1;                            { unbound                        }
  666.     T_IDLE                        = 2;                            { idle                            }
  667.     T_OUTCON                    = 3;                            { outgoing connection pending    }
  668.     T_INCON                        = 4;                            { incoming connection pending    }
  669.     T_DATAXFER                    = 5;                            { data transfer                }
  670.     T_OUTREL                    = 6;                            { outgoing orderly release        }
  671.     T_INREL                        = 7;                            { incoming orderly release        }
  672.  
  673. {    -------------------------------------------------------------------------
  674.     Flags used by option management calls to request services
  675.     ------------------------------------------------------------------------- }
  676.     T_NEGOTIATE                    = $004;
  677.     T_CHECK                        = $008;
  678.     T_DEFAULT                    = $010;
  679.     T_CURRENT                    = $080;
  680.  
  681. {    -------------------------------------------------------------------------
  682.     Flags used by option management calls to return results
  683.     ------------------------------------------------------------------------- }
  684.     T_SUCCESS                    = $020;
  685.     T_FAILURE                    = $040;
  686.     T_PARTSUCCESS                = $100;
  687.     T_READONLY                    = $200;
  688.     T_NOTSUPPORT                = $400;
  689.  
  690. {    -------------------------------------------------------------------------
  691.     General definitions
  692.     ------------------------------------------------------------------------- }
  693.     T_YES                        = 1;
  694.     T_NO                        = 0;
  695.     T_UNUSED                    = -1;
  696.     T_NULL                        = 0;
  697.     T_ABSREQ                    = $8000;
  698.  
  699. {    -------------------------------------------------------------------------
  700.     Option Management definitions
  701.     ------------------------------------------------------------------------- }
  702.     T_UNSPEC                    = 0+($FFFFFFFF - 2);
  703.     T_ALLOPT                    = 0;
  704.  
  705. {}
  706. { This macro will align return the value of "len", rounded up to the next}
  707. { 4-byte boundary.}
  708. {}
  709.  
  710. TYPE
  711.     OTConfiguration = RECORD
  712.     END;
  713.     OTConfigurationPtr = ^OTConfiguration;
  714.  
  715.     t_kpalive = RECORD
  716.         kp_onoff:                LONGINT;                                { option on/off        }
  717.         kp_timeout:                LONGINT;                                { timeout in minutes    }
  718.     END;
  719.  
  720. {
  721.      * Structure used with XTI_LINGER option
  722.      }
  723.     t_linger = RECORD
  724.         l_onoff:                LONGINT;                                { option on/off }
  725.         l_linger:                LONGINT;                                { linger time }
  726.     END;
  727.  
  728. {    -------------------------------------------------------------------------
  729.     TEndpointInfo - this structure is returned from the GetEndpointInfo call
  730.     and contains information about an endpoint
  731.     ------------------------------------------------------------------------- }
  732.     TEndpointInfo = RECORD
  733.         addr:                    SInt32;                                    { Maximum size of an address            }
  734.         options:                SInt32;                                    { Maximum size of options                }
  735.         tsdu:                    SInt32;                                    { Standard data transmit unit size        }
  736.         etsdu:                    SInt32;                                    { Expedited data transmit unit size    }
  737.         connect:                SInt32;                                    { Maximum data size on connect            }
  738.         discon:                    SInt32;                                    { Maximum data size on disconnect        }
  739.         servtype:                UInt32;                                    { service type (see below for values)    }
  740.         flags:                    UInt32;                                    { Flags (see below for values)            }
  741.     END;
  742.  
  743. {
  744.      * Values returned in servtype field of TEndpointInfo
  745.      }
  746.  
  747. CONST
  748.     T_COTS                        = 1;                            { Connection-mode service                                }
  749.     T_COTS_ORD                    = 2;                            { Connection service with orderly release                }
  750.     T_CLTS                        = 3;                            { Connectionless-mode service                            }
  751.     T_TRANS                        = 5;                            { Connection-mode transaction service                    }
  752.     T_TRANS_ORD                    = 6;                            { Connection transaction service with orderly release    }
  753.     T_TRANS_CLTS                = 7;                            { Connectionless transaction service                    }
  754.  
  755. {
  756.      * Values returned in flags field of TEndpointInfo
  757.      }
  758.     T_SENDZERO                    = $001;                            { supports 0-length TSDU's            }
  759.     T_XPG4_1                    = $002;                            { supports the GetProtAddress call    }
  760.     T_CAN_SUPPORT_MDATA            = $10000000;                    { support M_DATAs on packet protocols    }
  761.     T_CAN_RESOLVE_ADDR            = $40000000;                    { Supports ResolveAddress call            }
  762.     T_CAN_SUPPLY_MIB            = $20000000;                    { Supports SNMP MIB data                }
  763.  
  764. {
  765.      * Values returned in tsdu, etsdu, connect, and discon fields of TEndpointInfo
  766.      }
  767.     T_INFINITE                    = -1;                            { supports infinit amounts of data        }
  768.     T_INVALID                    = -2;                            { Does not support data transmission    }
  769.  
  770. {    -------------------------------------------------------------------------
  771.     OTPortRecord
  772.     ------------------------------------------------------------------------- }
  773. {
  774.      * Unique identifier for a port
  775.      }
  776.     
  777. TYPE
  778.     OTPortRef = UInt32;
  779.  
  780. {
  781.      * A couple of special values for the "port type" in an OTPortRef.
  782.      * See OpenTptLinks.h for other values.
  783.      * The device kOTPseudoDevice is used where no other defined
  784.      * device type will work.
  785.      }
  786.  
  787. CONST
  788.     kOTNoDeviceType                = 0;
  789.     kOTPseudoDevice                = 1023;
  790.     kOTLastDeviceIndex            = 1022;
  791.     kOTLastSlotNumber            = 255;
  792.     kOTLastOtherNumber            = 255;
  793.  
  794. {
  795.      * kMaxPortNameLength is the maximum size allowed to define
  796.      * a port
  797.      }
  798.     kMaxPortNameLength            = kMaxModuleNameLength + 4;
  799.     kMaxPortNameSize            = kMaxPortNameLength + 1;
  800.  
  801.     kInvalidPortRef                = 0+(0);                        { %%% Going away }
  802.     kOTInvalidPortRef            = 0+(0);
  803.  
  804. {
  805.      * Equates for the legal Bus-type values
  806.      }
  807.     kOTUnknownBusPort            = 0;
  808.     kOTMotherboardBus            = 1;
  809.     kOTNuBus                    = 2;
  810.     kOTPCIBus                    = 3;
  811.     kOTGeoPort                    = 4;
  812.     kOTPCMCIABus                = 5;
  813.     kOTLastBusIndex                = 15;
  814.  
  815.  
  816. TYPE
  817.     OTPortCloseStruct = RECORD
  818.         fPortRef:                OTPortRef;                                { The port requested to be closed.}
  819.         fTheProvider:            ProviderRef;                            { The provider using the port.}
  820.         fDenyReason:            OSStatus;                                { Set to a negative number to deny the request}
  821.     END;
  822.  
  823.  
  824. FUNCTION OTCreatePortRef(busType: ByteParameter; devType: UInt16; slot: UInt16; other: UInt16): OTPortRef;
  825. FUNCTION OTGetDeviceTypeFromPortRef(ref: OTPortRef): UInt16;
  826. FUNCTION OTGetBusTypeFromPortRef(ref: OTPortRef): UInt16;
  827. FUNCTION OTGetSlotFromPortRef(ref: OTPortRef; VAR other: UInt16): UInt16;
  828.  
  829. TYPE
  830.     OTPortRecord = RECORD
  831.         fRef:                    OTPortRef;
  832.         fPortFlags:                UInt32;
  833.         fInfoFlags:                UInt32;
  834.         fCapabilities:            UInt32;
  835.         fNumChildPorts:            size_t;
  836.         fChildPorts:            ^OTPortRef;
  837.         fPortName:                PACKED ARRAY [0..kMaxProviderNameSize-1] OF CHAR;
  838.         fModuleName:            PACKED ARRAY [0..kMaxModuleNameSize-1] OF CHAR;
  839.         fSlotID:                PACKED ARRAY [0..kMaxSlotIDSize-1] OF CHAR;
  840.         fResourceInfo:            PACKED ARRAY [0..kMaxResourceInfoSize-1] OF CHAR;
  841.         fReserved:                PACKED ARRAY [0..163] OF CHAR;
  842.     END;
  843.  
  844. {
  845.      * Values for the fInfoFlags field of OTPortRecord
  846.      }
  847.  
  848. CONST
  849.     kOTPortIsDLPI                = $00000001;
  850.     kOTPortIsTPI                = $00000002;
  851.     kOTPortCanYield                = $00000004;
  852.     kOTPortIsSystemRegistered    = $00004000;
  853.     kOTPortIsPrivate            = $00008000;
  854.     kOTPortIsAlias                = $80000000;
  855.  
  856. {
  857.      * Values for the fPortFlags field of TPortRecord
  858.      * If no bits are set, the port is currently inactive.
  859.      * kOTPortIsDisabled and kOTPortIsUnavailable may be set
  860.      * at the same time.  
  861.      }
  862.     kOTPortIsActive                = $00000001;
  863.     kOTPortIsDisabled            = $00000002;
  864.     kOTPortIsUnavailable        = $00000004;
  865.  
  866. {    -------------------------------------------------------------------------
  867.     TOptionHeader and TOption
  868.     
  869.     This structure describes the contents of a single option in a buffer
  870.     ------------------------------------------------------------------------- }
  871.  
  872. TYPE
  873.     TOptionHeader = RECORD
  874.         len:                    UInt32;                                    { total length of option                }
  875.         { = sizeof(TOptionHeader) + length        }
  876.         {     of option value in bytes            }
  877.         level:                    OTXTILevel;                                { protocol affected                    }
  878.         optName:                OTXTIName;                                { option name                            }
  879.         status:                    UInt32;                                    { status value                            }
  880.     END;
  881.  
  882.     TOption = RECORD
  883.         len:                    UInt32;                                    { total length of option                }
  884.         { = sizeof(TOption) + length    }
  885.         {     of option value in bytes            }
  886.         level:                    OTXTILevel;                                { protocol affected                    }
  887.         optName:                OTXTIName;                                { option name                            }
  888.         status:                    UInt32;                                    { status value                            }
  889.         value:                    ARRAY [0..0] OF UInt32;                    { data goes here                        }
  890.     END;
  891.  
  892.  
  893. CONST
  894.     kOTOptionHeaderSize            = sizeof(TOptionHeader);
  895.     kOTBooleanOptionDataSize    = sizeof(UInt32);
  896.     kOTBooleanOptionSize        = kOTOptionHeaderSize + kOTBooleanOptionDataSize;
  897.     kOTOneByteOptionSize        = kOTOptionHeaderSize + 1;
  898.     kOTTwoByteOptionSize        = kOTOptionHeaderSize + 2;
  899.     kOTFourByteOptionSize        = kOTOptionHeaderSize + sizeof(UInt32);
  900.  
  901. {    -------------------------------------------------------------------------
  902.     PollRef structure
  903.     
  904.     This is used with the OTStreamPoll function
  905.     ------------------------------------------------------------------------- }
  906.  
  907. TYPE
  908.     PollRef = RECORD
  909.         filler:                    LONGINT;
  910.         events:                    INTEGER;
  911.         revents:                INTEGER;
  912.         ref:                    StreamRef;
  913.     END;
  914.  
  915. {    -------------------------------------------------------------------------
  916.     OTClientList structure
  917.     
  918.     This is used with the OTYieldPortRequest function.
  919.     ------------------------------------------------------------------------- }
  920.     OTClientList = RECORD
  921.         fNumClients:            size_t;
  922.         fBuffer:                PACKED ARRAY [0..3] OF SInt8; (* UInt8 *)
  923.     END;
  924.  
  925. {    -------------------------------------------------------------------------
  926.     OTData
  927.     
  928.     This is a structure that may be used in a TNetbuf or netbuf to send
  929.     non-contiguous data.  Set the 'len' field of the netbuf to the
  930.     constant kNetbufDataIsOTData to signal that the 'buf' field of the
  931.     netbuf actually points to one of these structures instead of a
  932.     memory buffer.
  933.     ------------------------------------------------------------------------- }
  934.     OTData = RECORD
  935.         fNext:                    Ptr;
  936.         fData:                    Ptr;
  937.         fLen:                    size_t;
  938.     END;
  939.  
  940.  
  941. CONST
  942.     kNetbufDataIsOTData            = $fffffffe;
  943.  
  944. {    -------------------------------------------------------------------------
  945.     OTBuffer
  946.  
  947.     This is the structure that is used for no-copy receives.
  948.     When you are done with it, you must call the OTReleaseBuffer function.
  949.     For best performance, you need to call OTReleaseBuffer quickly.  Only
  950.     data netbufs may use this - no netbufs for addresses or options, or the like.
  951.     ------------------------------------------------------------------------- }
  952.  
  953. TYPE
  954.     OTBuffer = RECORD
  955.         fLink:                    Ptr;                                    { b_next & b_prev}
  956.         fLink2:                    Ptr;
  957.         fNext:                    ^OTBuffer;                                { b_cont}
  958.         fData:                    ^UInt8;                                    { b_rptr}
  959.         fLen:                    size_t;                                    { b_wptr}
  960.         fSave:                    Ptr;                                    { b_datap}
  961.         fBand:                    SInt8; (* UInt8 *)                        { b_band}
  962.         fType:                    SInt8; (* UInt8 *)                        { b_pad1}
  963.         fPad1:                    SInt8; (* UInt8 *)
  964.         fFlags:                    SInt8; (* UInt8 *)                        { b_flag}
  965.     END;
  966.  
  967. {    -------------------------------------------------------------------------
  968.     OTBufferInfo
  969.     
  970.     This structure is used with OTReadBuffer to keep track of where you
  971.     are in the buffer, since the OTBuffer is "read-only".
  972.     ------------------------------------------------------------------------- }
  973.     OTBufferInfo = RECORD
  974.         fBuffer:                ^OTBuffer;
  975.         fOffset:                size_t;
  976.         fPad:                    SInt8; (* UInt8 *)
  977.         fFiller:                SInt8; (* UInt8 *)
  978.     END;
  979.  
  980.  
  981. CONST
  982.     kOTNetbufDataIsOTBufferStar    = $fffffffd;
  983.  
  984. {    -------------------------------------------------------------------------
  985.     TNetbuf
  986.     
  987.     This structure is the basic structure used to pass data back and forth
  988.     between the Open Transport protocols and their clients
  989.     ------------------------------------------------------------------------- }
  990.  
  991. TYPE
  992.     TNetbuf = RECORD
  993.         maxlen:                    size_t;
  994.         len:                    size_t;
  995.         buf:                    Ptr;
  996.     END;
  997.  
  998. {    -------------------------------------------------------------------------
  999.     TBind
  1000.     
  1001.     Structure passed to GetProtAddress, ResolveAddress and Bind
  1002.     ------------------------------------------------------------------------- }
  1003.     TBind = RECORD
  1004.         addr:                    TNetbuf;
  1005.         qlen:                    OTQLen;
  1006.     END;
  1007.     TBindPtr = ^TBind;
  1008.  
  1009. {    -------------------------------------------------------------------------
  1010.     TDiscon
  1011.     
  1012.     Structure passed to RcvDisconnect to find out additional information
  1013.     about the disconnect
  1014.     ------------------------------------------------------------------------- }
  1015.     TDiscon = RECORD
  1016.         udata:                    TNetbuf;
  1017.         reason:                    OTReason;
  1018.         sequence:                OTSequence;
  1019.     END;
  1020.     TDisconPtr = ^TDiscon;
  1021.  
  1022. {    -------------------------------------------------------------------------
  1023.     TCall
  1024.     
  1025.     Structure passed to Connect, RcvConnect, Listen, Accept, and
  1026.     SndDisconnect to describe the connection.
  1027.     ------------------------------------------------------------------------- }
  1028.     TCall = RECORD
  1029.         addr:                    TNetbuf;
  1030.         opt:                    TNetbuf;
  1031.         udata:                    TNetbuf;
  1032.         sequence:                OTSequence;
  1033.     END;
  1034.  
  1035. {    -------------------------------------------------------------------------
  1036.     TUnitData
  1037.     
  1038.     Structure passed to SndUData and RcvUData to describe the datagram
  1039.     ------------------------------------------------------------------------- }
  1040.     TUnitData = RECORD
  1041.         addr:                    TNetbuf;
  1042.         opt:                    TNetbuf;
  1043.         udata:                    TNetbuf;
  1044.     END;
  1045.  
  1046. {    -------------------------------------------------------------------------
  1047.     TUDErr
  1048.     
  1049.     Structure passed to RcvUDErr to find out about a datagram error
  1050.     ------------------------------------------------------------------------- }
  1051.     TUDErr = RECORD
  1052.         addr:                    TNetbuf;
  1053.         opt:                    TNetbuf;
  1054.         error:                    SInt32;
  1055.     END;
  1056.  
  1057. {    -------------------------------------------------------------------------
  1058.     TOptMgmt
  1059.     
  1060.     Structure passed to the OptionManagement call to read or set protocol
  1061.     options.
  1062.     ------------------------------------------------------------------------- }
  1063.     TOptMgmt = RECORD
  1064.         opt:                    TNetbuf;
  1065.         flags:                    OTFlags;
  1066.     END;
  1067.  
  1068. {    -------------------------------------------------------------------------
  1069.     TRequest
  1070.     
  1071.     Structure passed to SndRequest and RcvRequest that contains the information
  1072.     about the request
  1073.     ------------------------------------------------------------------------- }
  1074.     TRequest = RECORD
  1075.         data:                    TNetbuf;
  1076.         opt:                    TNetbuf;
  1077.         sequence:                OTSequence;
  1078.     END;
  1079.  
  1080. {    -------------------------------------------------------------------------
  1081.     TReply
  1082.     
  1083.     Structure passed to SndReply to send a reply to an incoming request
  1084.     ------------------------------------------------------------------------- }
  1085.     TReply = RECORD
  1086.         data:                    TNetbuf;
  1087.         opt:                    TNetbuf;
  1088.         sequence:                OTSequence;
  1089.     END;
  1090.  
  1091. {    -------------------------------------------------------------------------
  1092.     TUnitRequest
  1093.     
  1094.     Structure passed to SndURequest and RcvURequest that contains the information
  1095.     about the request
  1096.     ------------------------------------------------------------------------- }
  1097.     TUnitRequest = RECORD
  1098.         addr:                    TNetbuf;
  1099.         opt:                    TNetbuf;
  1100.         udata:                    TNetbuf;
  1101.         sequence:                OTSequence;
  1102.     END;
  1103.  
  1104. {    -------------------------------------------------------------------------
  1105.     TUnitReply
  1106.     
  1107.     Structure passed to SndUReply to send a reply to an incoming request
  1108.     ------------------------------------------------------------------------- }
  1109.     TUnitReply = RECORD
  1110.         opt:                    TNetbuf;
  1111.         udata:                    TNetbuf;
  1112.         sequence:                OTSequence;
  1113.     END;
  1114.  
  1115. {    -------------------------------------------------------------------------
  1116.     TRegisterRequest
  1117.     ------------------------------------------------------------------------- }
  1118.     TRegisterRequest = RECORD
  1119.         name:                    TNetbuf;
  1120.         addr:                    TNetbuf;
  1121.         flags:                    OTFlags;
  1122.     END;
  1123.  
  1124. {    -------------------------------------------------------------------------
  1125.     TRegisterReply
  1126.     ------------------------------------------------------------------------- }
  1127.     TRegisterReply = RECORD
  1128.         addr:                    TNetbuf;
  1129.         nameid:                    OTNameID;
  1130.     END;
  1131.  
  1132. {    -------------------------------------------------------------------------
  1133.     TLookupRequest
  1134.     ------------------------------------------------------------------------- }
  1135.     TLookupRequest = RECORD
  1136.         name:                    TNetbuf;
  1137.         addr:                    TNetbuf;
  1138.         maxcnt:                    UInt32;
  1139.         timeout:                OTTimeout;
  1140.         flags:                    OTFlags;
  1141.     END;
  1142.  
  1143. {    -------------------------------------------------------------------------
  1144.     TLookupReply 
  1145.     
  1146.     Structure used by Mapper protocols to return the results of name Lookups
  1147.     ------------------------------------------------------------------------- }
  1148. {
  1149.      * This is the structure returned by the mapper for names that are
  1150.      * looked up.  
  1151.      }
  1152.     TLookupBuffer = RECORD
  1153.         fAddressLength:            UInt16;
  1154.         fNameLength:            UInt16;
  1155.         fAddressBuffer:            PACKED ARRAY [0..0] OF SInt8; (* UInt8 *)
  1156.     END;
  1157.  
  1158.     TLookupReply = RECORD
  1159.         names:                    TNetbuf;
  1160.         rspcount:                UInt32;
  1161.     END;
  1162.  
  1163. {******************************************************************************
  1164. ** C Interfaces to Open Transport
  1165. *******************************************************************************}
  1166. {    -------------------------------------------------------------------------
  1167.     Initializing and shutting down Open Transport
  1168.     ------------------------------------------------------------------------- }
  1169. {$IFC NOT OTKERNEL }
  1170.  
  1171. FUNCTION InitOpenTransport: OSStatus;
  1172. FUNCTION InitOpenTransportUtilities: OSStatus;
  1173. PROCEDURE CloseOpenTransport;
  1174. {}
  1175. { This registers yourself as a client for any miscellaneous Open Transport}
  1176. { notifications that come along. CloseOpenTransport will automatically do}
  1177. { an OTUnregisterAsClient, if you have not already done so.}
  1178. {}
  1179. FUNCTION OTRegisterAsClient(name: OTClientName; proc: OTNotifyProcPtr): OSStatus;
  1180. FUNCTION OTUnregisterAsClient: OSStatus;
  1181. {$ENDC}
  1182.  
  1183. PROCEDURE OTEnterInterrupt;
  1184. PROCEDURE OTLeaveInterrupt;
  1185. TYPE
  1186.     OTProcessProcPtr = ProcPtr;  { PROCEDURE (arg: UNIV Ptr); }
  1187.  
  1188.  
  1189. FUNCTION OTCreateDeferredTask(proc: OTProcessProcPtr; arg: UNIV Ptr): LONGINT;
  1190. FUNCTION OTScheduleDeferredTask(dtCookie: LONGINT): BOOLEAN;
  1191. FUNCTION OTScheduleInterruptTask(dtCookie: LONGINT): BOOLEAN;
  1192. FUNCTION OTDestroyDeferredTask(dtCookie: LONGINT): OSStatus;
  1193. {$IFC NOT OTKERNEL }
  1194. FUNCTION OTCreateSystemTask(proc: OTProcessProcPtr; arg: UNIV Ptr): LONGINT;
  1195. FUNCTION OTDestroySystemTask(stCookie: LONGINT): OSStatus;
  1196. FUNCTION OTScheduleSystemTask(stCookie: LONGINT): BOOLEAN;
  1197. FUNCTION OTCancelSystemTask(stCookie: LONGINT): BOOLEAN;
  1198. FUNCTION OTCanMakeSyncCall: BOOLEAN;
  1199. {$ENDC}
  1200. {$IFC NOT OTKERNEL }
  1201. FUNCTION OTGetIndexedPort(VAR record1: OTPortRecord; index: size_t): BOOLEAN;
  1202. FUNCTION OTFindPort(VAR record1: OTPortRecord; portName: ConstCStringPtr): BOOLEAN;
  1203. FUNCTION OTFindPortByRef(VAR record1: OTPortRecord; ref: OTPortRef): BOOLEAN;
  1204. {$ENDC}
  1205.  
  1206. TYPE
  1207.     strbuf = RECORD
  1208.         maxlen:                    LONGINT;                                { max buffer length }
  1209.         len:                    LONGINT;                                { length of data }
  1210.         buf:                    ^CHAR;                                    { pointer to buffer }
  1211.     END;
  1212.  
  1213. {$IFC NOT OTKERNEL }
  1214.  
  1215. FUNCTION OTCloseProvider(ref: ProviderRef): OSStatus;
  1216. FUNCTION OTTransferProviderOwnership(ref: ProviderRef; prevOwner: OTClient; VAR errPtr: OSStatus): ProviderRef;
  1217. FUNCTION OTWhoAmI: OTClient;
  1218. FUNCTION OTGetProviderPortRef(ref: ProviderRef): OTPortRef;
  1219. FUNCTION OTIoctl(ref: ProviderRef; cmd: UInt32; data: UNIV Ptr): SInt32;
  1220. FUNCTION OTGetMessage(ref: ProviderRef; VAR ctlbuf: strbuf; VAR databuf: strbuf; VAR flagPtr: OTFlags): OTResult;
  1221. FUNCTION OTGetPriorityMessage(ref: ProviderRef; VAR ctlbuf: strbuf; VAR databuf: strbuf; VAR bandPtr: OTBand; VAR flagPtr: OTFlags): OTResult;
  1222. FUNCTION OTPutMessage(ref: ProviderRef; {CONST}VAR ctlbuf: strbuf; {CONST}VAR databuf: strbuf; flags: OTFlags): OSStatus;
  1223. FUNCTION OTPutPriorityMessage(ref: ProviderRef; {CONST}VAR ctlbuf: strbuf; {CONST}VAR databuf: strbuf; band: OTBand; flags: OTFlags): OSStatus;
  1224. FUNCTION OTSetAsynchronous(ref: ProviderRef): OSStatus;
  1225. FUNCTION OTSetSynchronous(ref: ProviderRef): OSStatus;
  1226. FUNCTION OTIsSynchronous(ref: ProviderRef): BOOLEAN;
  1227. FUNCTION OTSetBlocking(ref: ProviderRef): OSStatus;
  1228. FUNCTION OTSetNonBlocking(ref: ProviderRef): OSStatus;
  1229. FUNCTION OTIsBlocking(ref: ProviderRef): BOOLEAN;
  1230. FUNCTION OTInstallNotifier(ref: ProviderRef; proc: OTNotifyProcPtr; contextPtr: UNIV Ptr): OSStatus;
  1231. PROCEDURE OTRemoveNotifier(ref: ProviderRef);
  1232. FUNCTION OTAckSends(ref: ProviderRef): OSStatus;
  1233. FUNCTION OTDontAckSends(ref: ProviderRef): OSStatus;
  1234. FUNCTION OTIsAckingSends(ref: ProviderRef): BOOLEAN;
  1235. FUNCTION OTCancelSynchronousCalls(ref: ProviderRef; err: OSStatus): OSStatus;
  1236. {$ENDC}
  1237. {$IFC NOT OTKERNEL }
  1238.  
  1239. FUNCTION OTOpenEndpoint(config: OTConfigurationPtr; oflag: OTOpenFlags; VAR info: TEndpointInfo; VAR err: OSStatus): EndpointRef;
  1240. FUNCTION OTAsyncOpenEndpoint(config: OTConfigurationPtr; oflag: OTOpenFlags; VAR info: TEndpointInfo; proc: OTNotifyProcPtr; contextPtr: UNIV Ptr): OSStatus;
  1241. {}
  1242. { Misc Information}
  1243. {}
  1244. FUNCTION OTGetEndpointInfo(ref: EndpointRef; VAR info: TEndpointInfo): OSStatus;
  1245. FUNCTION OTGetEndpointState(ref: EndpointRef): OTResult;
  1246. FUNCTION OTLook(ref: EndpointRef): OTResult;
  1247. FUNCTION OTSync(ref: EndpointRef): OTResult;
  1248. FUNCTION OTCountDataBytes(ref: EndpointRef; VAR countPtr: size_t): OTResult;
  1249. FUNCTION OTGetProtAddress(ref: EndpointRef; VAR boundAddr: TBind; VAR peerAddr: TBind): OSStatus;
  1250. FUNCTION OTResolveAddress(ref: EndpointRef; VAR reqAddr: TBind; VAR retAddr: TBind; timeOut: OTTimeout): OSStatus;
  1251. {}
  1252. { Allocating structures}
  1253. {}
  1254. FUNCTION OTAlloc(ref: EndpointRef; structType: OTStructType; fields: UInt32; VAR err: OSStatus): Ptr;
  1255. FUNCTION OTFree(ptr: UNIV Ptr; structType: OTStructType): OTResult;
  1256. {}
  1257. { Option management}
  1258. {}
  1259. FUNCTION OTOptionManagement(ref: EndpointRef; VAR req: TOptMgmt; VAR ret: TOptMgmt): OSStatus;
  1260. {}
  1261. { Bind/Unbind}
  1262. {}
  1263. FUNCTION OTBind(ref: EndpointRef; reqAddr: TBindPtr; retAddr: TBindPtr): OSStatus;
  1264. FUNCTION OTUnbind(ref: EndpointRef): OSStatus;
  1265. {}
  1266. { Connection creation/tear-down}
  1267. {}
  1268. FUNCTION OTConnect(ref: EndpointRef; VAR sndCall: TCall; VAR rcvCall: TCall): OSStatus;
  1269. FUNCTION OTRcvConnect(ref: EndpointRef; VAR call: TCall): OSStatus;
  1270. FUNCTION OTListen(ref: EndpointRef; VAR call: TCall): OSStatus;
  1271. FUNCTION OTAccept(ref: EndpointRef; resRef: EndpointRef; VAR call: TCall): OSStatus;
  1272. FUNCTION OTSndDisconnect(ref: EndpointRef; VAR call: TCall): OSStatus;
  1273. FUNCTION OTSndOrderlyDisconnect(ref: EndpointRef): OSStatus;
  1274. FUNCTION OTRcvDisconnect(ref: EndpointRef; discon: TDisconPtr): OSStatus;
  1275. FUNCTION OTRcvOrderlyDisconnect(ref: EndpointRef): OSStatus;
  1276. {}
  1277. { Connection-oriented send/receive}
  1278. {}
  1279. FUNCTION OTRcv(ref: EndpointRef; buf: UNIV Ptr; nbytes: size_t; VAR flags: OTFlags): OTResult;
  1280. FUNCTION OTSnd(ref: EndpointRef; buf: UNIV Ptr; nbytes: size_t; flags: OTFlags): OTResult;
  1281. {}
  1282. { non-connection oriented send/receive}
  1283. {}
  1284. FUNCTION OTSndUData(ref: EndpointRef; VAR udata: TUnitData): OSStatus;
  1285. FUNCTION OTRcvUData(ref: EndpointRef; VAR udata: TUnitData; VAR flags: OTFlags): OSStatus;
  1286. FUNCTION OTRcvUDErr(ref: EndpointRef; VAR uderr: TUDErr): OSStatus;
  1287. {}
  1288. { Connection-oriented transactions}
  1289. {}
  1290. FUNCTION OTSndRequest(ref: EndpointRef; VAR req: TRequest; reqFlags: OTFlags): OSStatus;
  1291. FUNCTION OTRcvReply(ref: EndpointRef; VAR reply: TReply; VAR replyFlags: OTFlags): OSStatus;
  1292. FUNCTION OTSndReply(ref: EndpointRef; VAR reply: TReply; replyFlags: OTFlags): OSStatus;
  1293. FUNCTION OTRcvRequest(ref: EndpointRef; VAR req: TRequest; VAR reqFlags: OTFlags): OSStatus;
  1294. FUNCTION OTCancelRequest(ref: EndpointRef; sequence: OTSequence): OSStatus;
  1295. FUNCTION OTCancelReply(ref: EndpointRef; sequence: OTSequence): OSStatus;
  1296. {}
  1297. { Connectionless transactions}
  1298. {}
  1299. FUNCTION OTSndURequest(ref: EndpointRef; VAR req: TUnitRequest; reqFlags: OTFlags): OSStatus;
  1300. FUNCTION OTRcvUReply(ref: EndpointRef; VAR reply: TUnitReply; VAR replyFlags: OTFlags): OSStatus;
  1301. FUNCTION OTSndUReply(ref: EndpointRef; VAR reply: TUnitReply; replyFlags: OTFlags): OSStatus;
  1302. FUNCTION OTRcvURequest(ref: EndpointRef; VAR req: TUnitRequest; VAR reqFlags: OTFlags): OSStatus;
  1303. FUNCTION OTCancelURequest(ref: EndpointRef; seq: OTSequence): OSStatus;
  1304. FUNCTION OTCancelUReply(ref: EndpointRef; seq: OTSequence): OSStatus;
  1305. {    -------------------------------------------------------------------------
  1306.     Interface to mappers
  1307.     ------------------------------------------------------------------------- }
  1308. FUNCTION OTAsyncOpenMapper(VAR config: OTConfiguration; oflag: OTOpenFlags; proc: OTNotifyProcPtr; contextPtr: UNIV Ptr): OSStatus;
  1309. FUNCTION OTOpenMapper(VAR config: OTConfiguration; oflag: OTOpenFlags; VAR err: OSStatus): MapperRef;
  1310. FUNCTION OTRegisterName(ref: MapperRef; VAR req: TRegisterRequest; VAR reply: TRegisterReply): OSStatus;
  1311. FUNCTION OTDeleteName(ref: MapperRef; VAR name: TNetbuf): OSStatus;
  1312. FUNCTION OTDeleteNameByID(ref: MapperRef; nameID: OTNameID): OSStatus;
  1313. FUNCTION OTLookupName(ref: MapperRef; VAR req: TLookupRequest; VAR reply: TLookupReply): OSStatus;
  1314. {    -------------------------------------------------------------------------
  1315.     Miscellaneous and generic functions
  1316.     ------------------------------------------------------------------------- }
  1317. FUNCTION OTAllocMem(size: size_t): Ptr; C;
  1318. PROCEDURE OTFreeMem(memptr: UNIV Ptr); C;
  1319. PROCEDURE OTDelay(seconds: UInt32);
  1320. PROCEDURE OTIdle;
  1321.     
  1322. FUNCTION OTCreateConfiguration(path: ConstCStringPtr): OTConfigurationPtr;
  1323. FUNCTION OTCloneConfiguration(cfig: OTConfigurationPtr): OTConfigurationPtr;
  1324. PROCEDURE OTDestroyConfiguration(cfig: OTConfigurationPtr);
  1325. FUNCTION OTCreateOptions(endPtName: ConstCStringPtr; strPtr: CStringPtr; VAR buf: TNetbuf): OSStatus;
  1326. FUNCTION OTCreateOptionString(endPtName: ConstCStringPtr; VAR opt: TOption; bufEnd: UNIV Ptr; strPTr: CStringPtr; stringSize: size_t): OSStatus;
  1327. FUNCTION OTNextOption(VAR buffer: UInt8; buflen: UInt32; VAR prevOptPtr: TOption): OSStatus;
  1328.     
  1329. TYPE
  1330.     TOptionPtr = ^TOption;
  1331.  
  1332.  
  1333. FUNCTION OTFindOption(VAR buffer: UInt8; buflen: UInt32; level: OTXTILevel; name: OTXTIName): TOptionPtr;
  1334. {$ENDC}
  1335.  
  1336. PROCEDURE OTMemcpy(dest: UNIV Ptr; src: UNIV Ptr; nBytes: size_t); C;
  1337. FUNCTION OTMemcmp(mem1: UNIV Ptr; mem2: UNIV Ptr; nBytes: size_t): BOOLEAN; C;
  1338. PROCEDURE OTMemmove(dest: UNIV Ptr; src: UNIV Ptr; nBytes: size_t); C;
  1339. PROCEDURE OTMemzero(dest: UNIV Ptr; nBytes: size_t); C;
  1340. PROCEDURE OTMemset(dest: UNIV Ptr; toSet: uchar_p; nBytes: size_t); C;
  1341. FUNCTION OTStrLength(strPtr: ConstCStringPtr): size_t; C;
  1342. PROCEDURE OTStrCopy(strTo: CStringPtr; strFrom: ConstCStringPtr); C;
  1343. PROCEDURE OTStrCat(strTo: CStringPtr; strFrom: ConstCStringPtr); C;
  1344. FUNCTION OTStrEqual(strPtr1: ConstCStringPtr; strPtr2: ConstCStringPtr): BOOLEAN; C;
  1345. {    -------------------------------------------------------------------------
  1346.     ** Time functions
  1347.     **    
  1348.     **    OTGetTimeStamp returns time in "tick" numbers, stored in 64 bits.
  1349.     **    This timestamp can be used as a base number for calculating elapsed 
  1350.     **    time.
  1351.     **    OTSubtractTimeStamps returns a pointer to the "result" parameter.
  1352.     **        
  1353.     **    OTGetClockTimeInSecs returns time since Open Transport was initialized
  1354.     **        in seconds.
  1355.     ------------------------------------------------------------------------- }
  1356.     
  1357. TYPE
  1358.     OTTimeStamp = UnsignedWide;
  1359.  
  1360.     OTTimeStampPtr = ^OTTimeStamp;
  1361.  
  1362.  
  1363. PROCEDURE OTGetTimeStamp(VAR stamp: OTTimeStamp); C;
  1364. FUNCTION OTSubtractTimeStamps(VAR result: OTTimeStamp; VAR startTime: OTTimeStamp; VAR endTime: OTTimeStamp): OTTimeStampPtr; C;
  1365. FUNCTION OTTimeStampInMilliseconds(VAR delta: OTTimeStamp): UInt32; C;
  1366. FUNCTION OTTimeStampInMicroseconds(VAR delta: OTTimeStamp): UInt32; C;
  1367. FUNCTION OTElapsedMilliseconds(VAR startTime: OTTimeStamp): UInt32; C;
  1368. FUNCTION OTElapsedMicroseconds(VAR startTime: OTTimeStamp): UInt32; C;
  1369. FUNCTION OTGetClockTimeInSecs: UInt32; C;
  1370. {    -------------------------------------------------------------------------
  1371.     ** OTLIFO
  1372.     **
  1373.     ** These are functions to implement a LIFO list that is interrupt-safe.
  1374.     ** The only function which is not is OTReverseList.  Normally, you create
  1375.     ** a LIFO list, populate it at interrupt time, and then use OTLIFOStealList
  1376.     ** to atomically remove the list, and OTReverseList to flip the list so that
  1377.     ** it is a FIFO list, which tends to be more useful.
  1378.     ------------------------------------------------------------------------- }
  1379.     
  1380. TYPE
  1381.     OTLinkPtr = ^OTLink;
  1382.  
  1383.     OTLIFO = RECORD
  1384.         fHead:                    ^OTLink;
  1385.     END;
  1386.  
  1387.     OTLink = RECORD
  1388.         fNext:                    ^OTLink;
  1389.     END;
  1390.  
  1391. {}
  1392. { This function puts "object" on the listHead, and places the}
  1393. { previous value at listHead into the pointer at "object" plus}
  1394. { linkOffset.}
  1395. {}
  1396.  
  1397. PROCEDURE OTEnqueue(listHead: UNIV Ptr; object: UNIV Ptr; linkOffset: size_t); C;
  1398. {}
  1399. { This function returns the head object of the list, and places}
  1400. { the pointer at "object" + linkOffset into the listHead}
  1401. {}
  1402. FUNCTION OTDequeue(listHead: UNIV Ptr; linkOffset: size_t): Ptr; C;
  1403. {}
  1404. { This function atomically enqueues the link onto the list}
  1405. {}
  1406. PROCEDURE OTLIFOEnqueue(VAR list: OTLIFO; VAR link: OTLink); C;
  1407. {}
  1408. { This function atomically dequeues the first element}
  1409. { on the list}
  1410. {}
  1411. FUNCTION OTLIFODequeue(VAR list: OTLIFO): OTLinkPtr; C;
  1412. FUNCTION OTLIFOStealList(VAR list: OTLIFO): OTLinkPtr; C;
  1413. FUNCTION OTReverseList(VAR list: OTLink): OTLinkPtr; C;
  1414.  
  1415. TYPE
  1416.     OTList = RECORD
  1417.         fHead:                    ^OTLink;
  1418.     END;
  1419.  
  1420.     OTListSearchProcPtr = ProcPtr;  { FUNCTION (ref: UNIV Ptr; VAR linkToCheck: OTLink): BOOLEAN; }
  1421.  
  1422. {}
  1423. { Add the link to the list at the front}
  1424. {}
  1425.  
  1426. PROCEDURE OTAddFirst(VAR list: OTList; VAR link: OTLink); C;
  1427. {}
  1428. { Add the link to the list at the end}
  1429. {}
  1430. PROCEDURE OTAddLast(VAR list: OTList; VAR link: OTLink); C;
  1431. {}
  1432. { Remove the first link from the list}
  1433. {}
  1434. FUNCTION OTRemoveFirst(VAR list: OTList): OTLinkPtr; C;
  1435. FUNCTION OTRemoveLast(VAR list: OTList): OTLinkPtr; C;
  1436. FUNCTION OTGetFirst(VAR list: OTList): OTLinkPtr; C;
  1437. FUNCTION OTGetLast(VAR list: OTList): OTLinkPtr; C;
  1438. FUNCTION OTIsInList(VAR list: OTList; VAR link: OTLink): BOOLEAN; C;
  1439. {}
  1440. { Find a link in the list which matches the search criteria}
  1441. { established by the search proc and the refPtr.  This is done}
  1442. { by calling the search proc, passing it the refPtr and each}
  1443. { link in the list, until the search proc returns true.}
  1444. { NULL is returned if the search proc never returned true.}
  1445. {}
  1446. FUNCTION OTFindLink(VAR listPtr: OTList; procPtr: OTListSearchProcPtr; refPtr: UNIV Ptr): OTLink; C;
  1447. {}
  1448. { Remove the specified link from the list, returning true if it was found}
  1449. {}
  1450. FUNCTION OTRemoveLink(VAR listPtr: OTList; VAR linkPtr: OTLink): BOOLEAN; C;
  1451. {}
  1452. { Similar to OTFindLink, but it also removes it from the list.}
  1453. {}
  1454. FUNCTION OTFindAndRemoveLink(VAR list: OTList; proc: OTListSearchProcPtr; refPtr: UNIV Ptr): OTLinkPtr; C;
  1455. FUNCTION OTGetIndexedLink(VAR list: OTList; index: size_t): OTLinkPtr; C;
  1456.     
  1457. TYPE
  1458.     OTLock = UInt8;
  1459.  
  1460.  
  1461. FUNCTION OTAtomicSetBit(VAR ptr: UInt8; len: size_t): BOOLEAN; C;
  1462. FUNCTION OTAtomicClearBit(VAR ptr: UInt8; len: size_t): BOOLEAN; C;
  1463. FUNCTION OTAtomicTestBit(VAR ptr: UInt8; len: size_t): BOOLEAN; C;
  1464. {}
  1465. { WARNING! void* and UInt32 locations MUST be on 4-byte boundaries.}
  1466. {            UInt16 locations must not cross a 4-byte boundary.}
  1467. {}
  1468. FUNCTION OTCompareAndSwapPtr(oldValue: UNIV Ptr; newValue: UNIV Ptr; location: UNIV Ptr): BOOLEAN; C;
  1469. FUNCTION OTCompareAndSwap32(oldValue: UInt32; newValue: UInt32; VAR location: UInt32): BOOLEAN; C;
  1470. FUNCTION OTCompareAndSwap16(oldValue: UInt32; newValue: UInt32; VAR location: UInt16): BOOLEAN; C;
  1471. FUNCTION OTCompareAndSwap8(oldValue: UInt32; newValue: UInt32; VAR location: UInt8): BOOLEAN; C;
  1472. {}
  1473. { WARNING! UInt32 locations MUST be on 4-byte boundaries.}
  1474. {            UInt16 locations must not cross a 4-byte boundary.}
  1475. {}
  1476. FUNCTION OTAtomicAdd32(val: SInt32; VAR ptr: SInt32): SInt32; C;
  1477. FUNCTION OTAtomicAdd16(val: SInt16; VAR ptr: SInt16): SInt16; C;
  1478. FUNCTION OTAtomicAdd8(val: ByteParameter; VAR ptr: SInt8): SInt8; C;
  1479.  
  1480. {$ALIGN RESET}
  1481. {$POP}
  1482.  
  1483. {$SETC UsingIncludes := OpenTransportIncludes}
  1484.  
  1485. {$ENDC} {__OPENTRANSPORT__}
  1486.  
  1487. {$IFC NOT UsingIncludes}
  1488.  END.
  1489. {$ENDC}
  1490.